home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume1 / vnews / part1 next >
Encoding:
Internet Message Format  |  1986-11-30  |  52.6 KB
  1. From: decvax!vax135!hou3c!ka
  2. Date: Mon, 21 Jan 85 21:39:51 est
  3. Newsgroups: mod.sources
  4. Subject: Vnews part 1
  5.  
  6. # Welcome to release 2.11-B 1/17/85 of vnews.  The -B means that this is
  7. # a prerelease of 2.11 vnews; a release 2.11 of vnews will not be issued
  8. # until a complete release 2.11 of netnews is ready.  Most features pro-
  9. # mised for release 2.11 are here.
  10. # 
  11. # This file is the first of seven files containing the vnews source.  To
  12. # unpack these files, chdir to an empty directory and feed them into the
  13. # shell.  Use the regular shell, not csh.
  14.  
  15. if test ! -d artfile
  16. then    mkdir artfile
  17. fi
  18.  
  19. cat > install.doc <<\!E!O!F!
  20.  
  21.                       HOW TO INSTALL VNEWS
  22.  
  23.  
  24.  
  25. This release is designed to run with release 2.10 or 2.10.1 of
  26. netnews, but should also work with release 2.10.2.  The steps re-
  27. quired to install vnews are:
  28.  
  29. 1)  Modify the transmit routine in inews to support the H flag.
  30. The H flag causes inews to replace a %s in the command with the
  31. contents of the history line.  The directory artfile contains two
  32. versions of the file ifuncs.c.  Ifuncs.c.10.1 is based on release
  33. 2.10.1 while ifuncs.c.10.2 is based on release 2.10.2.  In both
  34. files, the changes can be found by grepping for KSA.  Rebuild
  35. inews with the appropriate version of ifuncs.c.
  36.  
  37. 2)  Vnews has its own configuration program called "setup" which
  38. works on a file named config.  Change directory to lib, and run
  39. the mkconfig program.  This program expects as its single argu-
  40. ment the name of the directory containing the netnews source.
  41. You should probably cat the resulting config file to make sure it
  42. looks reasonable.  Then run the setup shell procedure.  Read
  43. setup.doc if you have problems.
  44.  
  45. 3)  If you have terminals with more than 24 lines or more than 80
  46. columns, increase MAXPLEN and MAXLLEN in vnews/virtterm.c.
  47.  
  48. 4)  The next step is to compile and install all the programs.
  49. Changing directory back to .. and running the compile shell pro-
  50. cedure will compile everything.  Compile will complain if you
  51. have distributions which it doesn't have descriptions for.  If
  52. this happens, add the descriptions to the file postnews/distlist
  53. and run compile again.  Compile -i will install all the programs.
  54. It will also add an entry to your sys file to invoke afinsert
  55. when new articles arrive.
  56.  
  57. 5)  Run /usr/lib/news/afbuild to create artfile and groupfile
  58. from the history file.  (Put it in the background; it's slow.)
  59. Since you don't want artfile to grow without bound, you must re-
  60. build it periodically.  Modify crontab to invoke afbuild after it
  61. calls expire.
  62.  
  63. 6)  You may wish to install vnews/vnews.1 and postnews/postnm.1
  64. in /usr/man.  Also, if you run Gosling's or Warren Montgomery's
  65. EMACS, install postnews/gparent.ml or postnews/gparent.wm,
  66. respectively, in some suitable spot.
  67.                                 Kenneth Almquist
  68. !E!O!F!
  69.  
  70. cat > files.doc <<\!E!O!F!
  71. .. Run this file throuhg nroff without any macro packages.
  72. .hy
  73. .de f
  74. .sp
  75. .ti 0
  76. .if \\w'\\$2' \\$1, installed in \\$2
  77. .if !\\w'\\$2' \\$1
  78. .in 8
  79. ..
  80. .de e
  81. .in 0
  82. ..
  83. This lists the programs and files which are part of vnews.
  84. For each file, the directory where it is installed is given.
  85. .f vnews/vnews /usr/bin
  86. This is the vnews news reading program.
  87. .f postnews/gparent /usr/bin
  88. This simple shell procedure writes writes the body of the article
  89. specified by $A to the standard output.  It is intended for writing
  90. followups which reference the original article.  For example from vi
  91. you can say ":r !gparent" to include the body of the original article
  92. in your followup.  (This only works from vnews because postnews
  93. does not yet set $A.)
  94. .f postnews/postnews /usr/bin
  95. This program allows users to post news items to the network.
  96. This version of postnews is much more sophisticated than the
  97. 2.10.1 version of postnews.  It is rather similar to the 2.10.2
  98. version except that it allows you to search for specific titles
  99. or authors if you don't remember the number of an article you are
  100. writng a followup to.
  101. .f postnews/postnm /usr/bin
  102. This program acts as a front end for inews.  To post news you should
  103. use this program instead of invoking inews directly.
  104. .f lib/cgtdate /usr/lib/news
  105. This is program converts a date to UNIX* internal format.
  106. It is invoked by vnews to process the -a option.
  107. .f postnews/postreply /usr/lib/news
  108. Thie program handles replies and followups for vnews.
  109. .f postnews/distributions /usr/lib/news
  110. This file lists all the legal distributions that users can specify
  111. (world, na, usa, local, etc.).
  112. .f postnews/moderators /usr/lib/news
  113. This file lists the moderators of various moderated groups.
  114. .f artfile/afbuild /usr/lib/news
  115. This program rebuilds /usr/lib/news/artfile from the history file.
  116. It also creates /usr/lib/news/groupfile if that file does not
  117. already exist.  (/usr/lib/news/artfile and /usr/lib/news/groupfile
  118. are described below.)
  119. .f artfile/afinsert /usr/lib/news
  120. This program is invoked by an entry in the sys file every time an
  121. article is received.  Its single argument is the contents of the
  122. history line for the article.  This program adds an entry for the
  123. article to /usr/lib/news/artfile.
  124. .f artfile/dumprec
  125. This program writes out records in artfile.  Each record is specified
  126. either by a message-ID or by its offset from the beginning of artfile.
  127. This program is intended for debugging the artfile code.
  128. .f artfile/dumpng
  129. This program lists the contents of a newsgroup.  It is also intended
  130. for debugging the artfile code, but the information may prove useful
  131. for other purposes.
  132. .f /usr/lib/news/artfile
  133. This file contains one entry for each article in the system.
  134. It can be accessed by various routines in lib/rlib.a; see lib/routines.doc
  135. for details.
  136. .f /usr/lib/news/groupfile
  137. This file associates a small, unique integer with each newsgroup
  138. on the system.
  139. .f postnews/gparent.ml
  140. This is a macro for Gosling's EMACS that reads the body of the article
  141. specified by $A into the current buffer.  It is intended for writing
  142. followups which reference the original article.  Normally, this macro
  143. should be bound to ^X^Y.  Compile -i will not install this anywhere,
  144. but if you run Gosling's EMACS you should install it wherever you have
  145. your macro library.
  146. .f postnews/gparent.wm
  147. This file contains a version of the gparent macro rewritten to run
  148. under Warren Montgomery's EMACS.
  149. !E!O!F!
  150.  
  151. cat > compile <<\!E!O!F!
  152. #!/bin/sh
  153. : This file compiles all of vnews.
  154. : With the -i option, it also installs everything
  155. : The -f option forces a remake of everything.
  156. : The -n option is passed to make.
  157. : Arguments like DEBUG=-g are passed to make.
  158.  
  159. case "$0" in
  160. ../compile)    cd .. ;;
  161. esac
  162.  
  163. . lib/makedefs
  164.  
  165. dirs=
  166. install=
  167. frc=
  168. makedefs=
  169. for x 
  170. do    case "$x" in
  171.     -i)    install=install ;;
  172.     -f)    frc="FRC=FRC" ;;
  173.     -n)    makedefs="-n|$makedefs" ;;
  174.     *=*)    makedefs="$makedefs|$x" ;;
  175.     -*)    echo 'Usage: compile [ -i ] [ directories ]'
  176.         exit 1 ;;
  177.     *)    dirs="$dirs $x" ;;
  178.     esac
  179. done
  180. if test "$dirs" = ""
  181. then    dirs=lib
  182.     for x in *
  183.     do    if test "$x" != lib -a -f $x/genmakefile
  184.         then    dirs="$dirs $x"
  185.         fi
  186.     done
  187. fi
  188.  
  189. cd lib
  190. for x in $dirs
  191. do    echo "Making $x:"
  192.     cd ../$x
  193.     if test "$frc" != "" -o ! -f ../lib/newer || ../lib/newer genmakefile makefile
  194.     then    echo "    genmakefile"
  195.         genmakefile
  196.     fi
  197.     IFS='|'
  198.     echo "    make" $makedefs $frc $install
  199.     make $makedefs $frc $install || exit
  200.     IFS='     
  201. '
  202. done
  203.  
  204. if test "$install" = "" || grep '^artfile:' $LIBDIR/sys > /dev/null
  205. then    :
  206. else    echo adding artfile entry to sys file
  207.     echo "artfile:all:H:$LIBDIR/afinsert \"%s\"" >> $LIBDIR/sys
  208.     echo "Remember to update crontab to invoke $LIBDIR/afbuild every night"
  209. fi
  210. echo Compile all done
  211. !E!O!F!
  212. chmod +x compile
  213.  
  214. cat > artfile/addart.c <<\!E!O!F!
  215. #include <stdio.h>
  216. #include <sys/types.h>
  217. #include "config.h"
  218. #include "defs.h"
  219. #include "arthead.h"
  220. #include "af.h"
  221.  
  222.  
  223. #define equal(s1, s2)    (strcmp(s1, s2) == 0)
  224. char *rindex(), *savestr() ;
  225. char *getaddr() ;
  226. time_t cgtdate() ;
  227. DPTR addrec() ;
  228.  
  229. extern int newgroup ;
  230.  
  231.  
  232. /*
  233.  * Add an article to the data base.
  234.  * Glitches:
  235.  *    Ignore the message id <>, since it is clearly wrong (rn bug).
  236.  *    Ignore message ids without a trailing '>' since probably truncated.
  237.  */
  238.  
  239. addart(h, fname, groups)
  240.       struct arthead *h ;
  241.       char *fname ;
  242.       char *groups ;
  243.       {
  244.       struct artrec a ;
  245.       char buf[128] ;
  246.       char *parlist[32], **pp ;
  247.       struct artgroup *gp ;
  248.       register char *p, *q ;
  249.  
  250.       h->h_subtime = cgtdate(h->h_subdate) ;
  251.       h->h_rectime = cgtdate(h->h_recdate) ;
  252.       if (hset(h->h_expdate))
  253.             h->h_exptime = cgtdate(h->h_expdate) ;
  254.       else
  255.             h->h_exptime = 0L ;
  256.  
  257.       p = groups; gp = a.a_group ;
  258.       while (*p && gp < &a.a_group[MAXNG]) {
  259.             q = buf ;
  260.             while (*p == ' ')
  261.                   p++ ;
  262.             while (*p != '/') {
  263.                   if (*p == '\0')
  264.                         xerror("bad newsgroup list") ;
  265.                   *q++ = *p++ ;
  266.             }
  267.             *q = '\0' ;
  268.             if ((gp->a_ngnum = ngnum(buf)) <= 0) {
  269.                   gp->a_ngnum = newng(buf) ;
  270.                   newgroup++ ;
  271.             }
  272.             p++ ;
  273.             gp->a_artno = atoi(p) ;
  274.             while (*p != ' ' && *p)
  275.                   p++ ;
  276.             gp++ ;
  277.       }
  278.       a.a_ngroups = gp - a.a_group ;
  279.  
  280.       pp = parlist + 31 ; parlist[31] = NULL ;
  281.       p = h->h_references ;
  282.       while (p && *p) {
  283.             if (pp <= parlist)
  284.                   xerror("Too many references") ;
  285.             q = buf ;
  286.             while (*p && *p != ',' && *p != ' ')
  287.                   *q++ = *p++ ;
  288.             *q = '\0' ;
  289.             tomsgid(buf) ;
  290.             if (! equal(buf, "<>"))
  291.                   *--pp = savestr(buf) ;
  292.             while (*p == ' ' || *p == ',')
  293.                   p++ ;
  294.       }
  295.       while (*pp && index(*pp, '>') == 0)
  296.             pp++ ;
  297.       if (strlen(h->h_title) > 127)
  298.             h->h_title[127] = '\0' ;
  299.       getaddr(h->h_from, buf) ;
  300.  
  301.       a.a_subtime = h->h_subtime ;
  302.       a.a_rectime = h->h_rectime ;
  303.       a.a_exptime = h->h_exptime ;
  304.       a.a_parent = DNULL ;
  305.       a.a_children = DNULL ;
  306.       a.a_childchain = DNULL ;
  307.       a.a_nlines = h->h_intnumlines ;
  308.       a.a_flags = 0 ;
  309.       a.a_ident = h->h_ident ;
  310.       a.a_title = h->h_title ;
  311.       a.a_from = buf ;
  312.       a.a_file = fname ;
  313.       a.a_nkwords = 0 ;        /* fix this eventually */
  314.       addrec(&a, pp) ;
  315.  
  316.       while (*pp)
  317.             free(*pp++) ;
  318. }
  319. !E!O!F!
  320.  
  321. cat > artfile/addrec.c <<\!E!O!F!
  322. #include <stdio.h>
  323. #include "af.h"
  324.  
  325.  
  326. static int nchildren ;            /* number of orphaned children */
  327. static DPTR child[200] ;        /* list of orphans */
  328.  
  329. long lseek() ;
  330.  
  331.  
  332. /*
  333.  * Add a record to the data base.
  334.  */
  335.  
  336. DPTR
  337. addrec(a, parlist)
  338.       struct artrec *a ;
  339.       char **parlist ;
  340.       {
  341.       DPTR pos ;
  342.       DPTR idhash, thash ;
  343.       DPTR ngptr[MAXNG] ;
  344.       DPTR dp ;
  345.       int i, j ;
  346.       static char nuls[60] ;
  347.       DPTR htitle();
  348.  
  349.       dorelatives(a, parlist) ;
  350.       idhash = hashid(a->a_ident) ;
  351.       a->a_idchain = readptr(idhash) ;
  352.       if ((a->a_flags & A_DUMMY) == 0) {
  353.             thash = htitle(a->a_title) ;
  354.             a->a_titlechain = readptr(thash) ;
  355.       }
  356.       for (i = 0 ; i < a->a_ngroups ; i++) {
  357.             struct artrec a2 ;
  358.             int ng = a->a_group[i].a_ngnum ;
  359.  
  360.             /* insert record in proper place in chain */
  361.             dp = readptr(ngptr[i] = ngchain(ng)) ;
  362.             while (dp != DNULL) {
  363.                   readrec(dp, &a2) ;
  364.                   for (j = 0 ; ; j++) {
  365.                         if (j >= a2.a_ngroups)
  366.                               xerror("bad newsgroup chain for %d", ng) ;
  367.                         if (a2.a_group[j].a_ngnum == ng)
  368.                               break ;
  369.                   }
  370.                   if (a2.a_group[j].a_artno <= a->a_group[i].a_artno)
  371.                         break ;
  372.                   ngptr[i] = dp + GROUPOFF + stroff(a_ngchain, artgroup) + j * sizeof(struct artgroup) ;
  373.                   dp = a2.a_group[j].a_ngchain ;
  374.             }
  375.             a->a_group[i].a_ngchain = dp ;
  376.       }
  377.       pos = afhd.af_free ;
  378.       lseek(affd, (long)pos, 0) ;
  379.       writerec(a, affd) ;
  380.       afhd.af_free = lseek(affd, 0L, 1) ;
  381.       write(affd, nuls, 60) ;        /* readrec tends to overrun */
  382.       lseek(affd, 0L, 0) ;
  383.       write(affd, (char *)&afhd, sizeof afhd) ;
  384.       writeptr(pos, idhash) ;
  385.       if ((a->a_flags & A_DUMMY) == 0)
  386.             writeptr(pos, thash) ;
  387.       if (a->a_parent)
  388.             writeptr(pos, a->a_parent + CHILDRENOFF) ;
  389.       for (i = 0 ; i < nchildren ; i++) {
  390.             writeptr(pos, child[i] + PARENTOFF) ;
  391.       }
  392.       for (i = 0 ; i < a->a_ngroups ; i++) {
  393.             writeptr(pos, ngptr[i]) ;
  394.       }
  395.       return pos ;
  396. }
  397.  
  398.  
  399.  
  400. /*
  401.  * Find the parents and children of the article.
  402.  * If the references line is present,
  403.  *    create a dummy entry for parent if necessary.
  404.  * If no references line, guess at parent using title.
  405.  * Look for articles without references lines whose titles indicate that
  406.  *    this article might be the parent.
  407.  */
  408.  
  409. dorelatives(a, parlist)
  410.       register struct artrec *a ;
  411.       char **parlist ;
  412.       {
  413.       struct artrec a2 ;
  414.       DPTR dp, dp2, dummy ;
  415.       int i ;
  416.  
  417.       /* first look for parent */
  418.       if (parlist && parlist[0]) {
  419.             if ((a->a_parent = lookart(parlist[0], &a2)) == DNULL) {
  420.                   /* make dummy parent */
  421.                   bzero((char *) &a2, sizeof a2) ;
  422.                   a2.a_ident = parlist[0] ;
  423.                   a2.a_flags = A_DUMMY ;
  424.                   a2.a_rectime = a->a_rectime;
  425.                   a2.a_subtime = a->a_subtime;
  426.                   a->a_parent = addrec(&a2, parlist + 1) ;
  427.             }
  428.       } else if (a->a_title && isre(a->a_title)) {
  429.             for (dp = readptr(htitle(a->a_title)) ; dp != NULL ; dp = a2.a_titlechain) {
  430.                   readrec(dp, &a2) ;
  431.                   if (tparent(&a2, a)) {
  432.                         a->a_parent = dp ;
  433.                         break ;
  434.                   }
  435.             }
  436.       }
  437.       /* check for loops in parent relation */
  438.       if ((dummy = lookart(a->a_ident, &a2)) != DNULL) {
  439.             /* we are replacing a dummy entry with a real one */
  440.             i = 100 ;
  441.             for (dp2 = a->a_parent ; dp2 != DNULL ; dp2 = a2.a_parent) {
  442.                   readrec(dp2, &a2) ;
  443.                   if (dp2 == dummy) {
  444.                         a->a_parent = a2.a_parent ;
  445.                         printf("loop in parent chain for %s found\n", a->a_ident) ;
  446.                         break ;
  447.                   }
  448.                   if (--i < 0) {
  449.                         printf("loop containing %s discovered while updating %s\n",
  450.                               a2.a_ident, a->a_ident) ;
  451.                         break ;
  452.                   }
  453.             }
  454.       }
  455.  
  456.       /* now look for orphans */
  457.       nchildren = 0 ;
  458.       if (dummy != DNULL) {
  459.             /* we are replacing a dummy entry with a real one */
  460.             readrec(dummy, &a2) ;
  461.             if (a2.a_parent != DNULL)
  462.                   rmchain(a2.a_parent + CHILDRENOFF, CHILDCHOFF, dummy) ;
  463.             for (dp = a2.a_children ; dp != DNULL ; dp = a2.a_childchain) {
  464.                   child[nchildren++] = dp ;
  465.                   readrec(dp, &a2) ;
  466.             }
  467.             writeptr(DNULL, dp + CHILDRENOFF) ;
  468.       }
  469.       if (a->a_parent != DNULL) {
  470.             readrec(a->a_parent, &a2);
  471.             a->a_childchain = a2.a_children ;
  472.       } else
  473.             a->a_childchain = DNULL ;
  474.       if ((a->a_flags & A_DUMMY) == 0)
  475.          for (dp = readptr(htitle(a->a_title)) ; dp != DNULL ; dp = a2.a_titlechain) {
  476.             readrec(dp, &a2) ;
  477.             if (a2.a_parent == DNULL && tparent(a, &a2))
  478.                   child[nchildren++] = dp ;
  479.       }
  480.  
  481.       /* link the orhpans together into the child chain */
  482.       child[nchildren] = DNULL ;
  483.       for (i = 0 ; i < nchildren ; i++) {
  484.             DPTR pardp = readptr(child[i] + PARENTOFF) ;    /*DEBUG*/
  485.             if (pardp != DNULL && pardp != dummy)
  486.                   printf("bad orphan %ld: par %ld, dummy %ld\n", child[i], pardp, dummy) ;
  487.             writeptr(child[i + 1], child[i] + CHILDCHOFF) ;
  488.       }
  489.       a->a_children = child[0] ;
  490. }
  491.  
  492.  
  493.  
  494. /* remove an entry from a linked list */
  495.  
  496. rmchain(chain, offset, rec)
  497.       DPTR chain ;
  498.       DPTR rec ;
  499.       {
  500.       DPTR dp ;
  501.       int nremoved = 0 ;    /*DEBUG*/
  502.       DPTR svchain = chain ;    /*DEBUG*/
  503.  
  504.       dp = readptr(chain) ;
  505.       while (dp != DNULL) {
  506.             if (dp == rec) {
  507.                   writeptr(readptr(dp + offset), chain) ;
  508.                   nremoved++;
  509.             }
  510.             chain = dp + offset ;
  511.             dp = readptr(chain) ;
  512.       }
  513.       if (nremoved == 0)
  514.             printf("rmchain(%ld, %d, %ld) failed\n", svchain, offset, rec) ;
  515. }
  516. !E!O!F!
  517.  
  518. cat > artfile/afbuild.c <<\!E!O!F!
  519. #include <stdio.h>
  520. #include "config.h"
  521. #include <sys/types.h>
  522. #include <sys/stat.h>
  523. #include "newsdefs.h"
  524. #include "af.h"
  525.  
  526.  
  527. char *index() ;
  528. FILE *ckfopen() ;
  529.  
  530. static int idsize = 10007 ;    /* default size of message ID hash table */
  531. static int grpsize =  512 ;    /* default maximum newsgroup number */
  532. static int ttlsize = 5003 ;    /* default size of title hash table */
  533.  
  534. char progname[] = "afbuild" ;
  535. int newgroup ;
  536.  
  537.  
  538. main(argc, argv)
  539.       char **argv ;
  540.       {
  541.       int c ;
  542.       char curname[64], newname[64] ;
  543.       char buf[256] ;
  544.       char histname[64] ;
  545.       FILE *histfp ;
  546.       extern char LIB[], SPOOL[] ;
  547.       extern char *optarg ;
  548.  
  549.       setbuf(stdout, NULL) ;
  550. #if BSDREL >= 41
  551.       setbuf(stderr, NULL) ;
  552. #endif
  553.       pathinit() ;
  554.       sprintf(histname, "%s/history", LIB) ;
  555.       while ((c = getopt(argc, argv, "h:m:g:t:")) != EOF) switch (c) {
  556.             case 'h':
  557.                   scopyn(optarg, histname, 64) ;
  558.                   break ;
  559.             case 'm':
  560.                   idsize = numarg(c) ;
  561.                   break ;
  562.             case 'g':
  563.                   grpsize = numarg(c) ;
  564.                   break ;
  565.             case 't':
  566.                   ttlsize = numarg(c) ;
  567.                   break ;
  568.       }
  569.       sprintf(curname, "%s/artfile", LIB) ;
  570.       sprintf(newname, "%s.tmp", curname) ;
  571.       unlink(newname) ;
  572.       makeaf(newname, idsize, grpsize, ttlsize) ;
  573.       if (strcmp(histname, "none") != 0) {
  574.             readngtab() ;
  575.             genafopen(newname, "r+") ;
  576.             if ((histfp = fopen(histname, "r")) == NULL)
  577.                   xerror("Can't open history file") ;
  578.             if (chdir(SPOOL) < 0)
  579.                   xerror("Can't chdir to %s", SPOOL) ;
  580.             while (fgets(buf, 256, histfp) != NULL)
  581.                   doadd(buf, 0) ;
  582.             if (newgroup)
  583.                   writengfile() ;
  584.       }
  585.       aflock() ;
  586.       sleep(10) ;        /* let the dust settle */
  587.       while (fgets(buf, 256, histfp) != NULL)
  588.             doadd(buf, 0) ;
  589.       close(affd) ;
  590.       if (rename(newname, curname) < 0)
  591.             xerror("rename failed") ;
  592.       afunlock() ;
  593.       sync() ;
  594.       exit(0) ;
  595. }
  596.  
  597.  
  598.  
  599. numarg(c) {
  600.       extern char *optarg ;
  601.       register char *p ;
  602.  
  603.       for (p = optarg ; *p ; p++)
  604.             if (*p < '0' || *p > '9')
  605.                   xerror("Illegal number after -%c option", c) ;
  606.       return atoi(optarg) ;
  607. }
  608.  
  609.  
  610.  
  611. readngtab() {
  612.       char file[FPATHLEN] ;
  613.       FILE *fp ;
  614.       struct stat statb ;
  615.       char line[512] ;
  616.       register char *p ;
  617.       extern char LIB[] ;
  618.  
  619.       sprintf(file, "%s/groupfile", LIB) ;
  620.       if (stat(file, &statb) >= 0 && statb.st_size > 0) {
  621.             getngtab() ;
  622.       } else {
  623.             fprintf(stderr, "afbuild: reconstructing groupfile.\n") ;
  624.             ngtinit() ;
  625.             sprintf(file, "%s/active", LIB) ;
  626.             fp = ckfopen(file, "r") ;
  627.             while (fgets(line, 512, fp) != NULL) {
  628.                   if (line[0] == '\n')
  629.                         continue ;
  630.                   if ((p = index(line, ' ')) != NULL)
  631.                         *p = '\0' ;
  632.                   if ((p = index(line, '\n')) != NULL)
  633.                         *p = '\0' ;
  634.                   newng(line) ;
  635.                   newgroup++ ;
  636.             }
  637.       }
  638. }
  639.  
  640.  
  641.  
  642. xerror(msg, a1, a2, a3, a4)
  643.       char *msg ;
  644.       {
  645.       extern int errno ;
  646.       int e = errno ;
  647.  
  648.       fputs("afbuild: ", stderr) ;
  649.       fprintf(stderr, msg, a1, a2, a3, a4) ;
  650.       putc('\n', stderr) ;
  651.       fprintf(stderr, "errno=%d\n", e) ;
  652.       fflush(stderr) ;        /* 4.2 BSD buffers stderr! */
  653.       exit(2) ;
  654. }
  655. !E!O!F!
  656.  
  657. cat > artfile/afinsert.c <<\!E!O!F!
  658. /*
  659.  * This program inserts entries into the artfile.
  660.  */
  661.  
  662. #include <stdio.h>
  663. #include "af.h"
  664. #include <sys/types.h>
  665. #include "defs.h"
  666.  
  667. int newgroup ;
  668. char progname[] = "afinsert" ;
  669. extern char LIB[] ;
  670. extern char SPOOL[] ;
  671.  
  672.  
  673. main(argc, argv)
  674.       char **argv ;
  675.       {
  676.       int c ;
  677.       char afname[64] ;
  678.  
  679.       setbuf(stdout, NULL) ;
  680. #if BSDREL >= 41
  681.       setbuf(stderr, NULL) ;
  682. #endif
  683.       if (argc != 2)
  684.             xerror("Usage: afinsert hist-line") ;
  685.       sprintf(afname, "%s/artfile", LIB) ;
  686.       genafopen(afname, "r+") ;
  687.       getngtab() ;
  688.       if (chdir(SPOOL) < 0)
  689.             xerror("Can't chdir to spool") ;
  690.       doadd(argv[1], 1) ;
  691.       if (newgroup)
  692.             writengfile() ;
  693.       exit(0) ;
  694. }
  695.  
  696.  
  697.  
  698. xerror(msg, a1, a2, a3, a4)
  699.       char *msg ;
  700.       {
  701.       printf(msg, a1, a2, a3, a4) ;
  702.       putchar('\n') ;
  703.       abort() ;
  704. }
  705. !E!O!F!
  706.  
  707. cat > artfile/doadd.c <<\!E!O!F!
  708. #include <stdio.h>
  709. #include <sys/types.h>
  710. #include "config.h"
  711. #include "defs.h"
  712. #include "arthead.h"
  713.  
  714.  
  715. char *index() ;
  716.  
  717.  
  718. doadd(hist, lockit)
  719.       char *hist ;
  720.       {
  721.       FILE *artfp ;
  722.       char fname[64] ;
  723.       struct arthead h ;
  724.       register char *p ;
  725.       extern char progname[] ;
  726.  
  727.       bzero((char *)&h, sizeof h) ;
  728.       if ((p = index(hist, '\t')) == NULL) {
  729. bad:        printf("Bad history line") ;
  730.             return ;
  731.       }
  732.       p++ ;
  733.       if ((p = index(p, '\t')) == NULL)
  734.             goto bad ;
  735.       p++ ;
  736.       nstrip(p) ;
  737.       hist = p ;
  738.       scopyn(p, fname, 64) ;
  739.       if ((p = index(fname, ' ')) != NULL)
  740.             *p = '\0' ;
  741.       for (p = fname ; *p ; p++)
  742.             if (*p == '.')
  743.                   *p = '/' ;
  744.       if ((artfp = fopen(fname, "r")) == NULL) {
  745.             printf("%s: can't open %s\n", progname, fname) ;
  746.             return ;
  747.       }
  748.       if (gethead(&h, artfp) == NULL) {
  749.             printf("%s: bad header\n", fname) ;
  750.             return ;
  751.       }
  752.       h.h_intnumlines = countlines(artfp) ;
  753.       if (lockit)  aflock() ;
  754.       addart(&h, fname, hist) ;
  755.       if (lockit)  afunlock() ;
  756.       fclose(artfp) ;
  757.       hfree(&h) ;
  758. }
  759.  
  760.  
  761.  
  762. countlines(fp)
  763.       register FILE *fp ;
  764.       {
  765.       register c ;
  766.       int curline, nlines ;
  767.  
  768.       curline = 1 ;
  769.       nlines = 0 ;
  770.       while ((c = getc(fp)) != EOF) {
  771.             if (c == '\n')
  772.                   curline++ ;
  773.             else
  774.                   nlines = curline ;
  775.       }
  776.       return nlines ;
  777. }
  778. !E!O!F!
  779.  
  780. cat > artfile/dumpng.c <<\!E!O!F!
  781. #include <stdio.h>
  782. #include "af.h"
  783. #include "ng.h"
  784. #include <setjmp.h>
  785.  
  786. struct jump {
  787.       jmp_buf jbuf ;
  788.       struct jump *nextj ;
  789. } *jmp ;
  790.  
  791.  
  792.  
  793. main(argc, argv)
  794.       char **argv ;
  795.       {
  796.       char **ap = argv + 1 ;
  797.       char *gname ;
  798.       int gnum ;
  799.       struct artrec a ;
  800.       DPTR dp ;
  801.       char artfile[64] ;
  802.       struct jump j ;
  803.       extern int LIB[] ;
  804.       long atol() ;
  805.  
  806.       jmp = &j ;
  807.       if (setjmp(j.jbuf)) {
  808.             exit(2) ;
  809.       }
  810.       if (argc < 2)
  811.             xerror("Usage: dumpng -fartfile -n newsgroup...") ;
  812.       pathinit() ;
  813.       sprintf(artfile, "%s/artfile", LIB) ;
  814.       if (strncmp(*ap, "-f", 2) == 0) {
  815.             if (ap[0][2])     strcpy(artfile, *ap + 2) ;
  816.             else              strcpy(artfile, *++ap) ;
  817.             ap++ ;
  818.       }
  819.       genafopen(artfile, "r") ;
  820.       gfopen() ;
  821.  
  822.       while ((gname = *ap++) != NULL) {
  823.             if ((gnum = prtngheader(gname)) >= 0) {
  824.                   prtngchain(gname, gnum) ;
  825.             }
  826.       }
  827.       exit(0) ;
  828. }
  829.  
  830.  
  831.  
  832. prtngheader(gname)
  833.       char *gname ;
  834.       {
  835.       struct ngrec g ;
  836.  
  837.       ALL_GROUPS(g) {
  838.             if (strcmp(g.g_name, gname) == 0)
  839.                   goto found ;
  840.       }
  841.       printf("\nUnknown newsgroup %s\n", gname) ;
  842.       return -1 ;
  843.  
  844. found:
  845.       printf("\nNewsgroup %s (%d)", g.g_name, g.g_num) ;
  846.       if (g.g_flags & G_MOD)
  847.             printf("  moderated") ;
  848.       printf("\n\n") ;
  849.       return g.g_num ;
  850. }
  851.  
  852.  
  853.  
  854. prtngchain(gname, gnum)
  855.       char *gname ;
  856.       {
  857.       DPTR dp ;
  858.       struct artrec a ;
  859.       ARTNO an ;
  860.       int i ;
  861.  
  862.       BKWD_GROUP(gnum, an, dp, a) {
  863.             for (i = 0 ; ; i++) {
  864.                   if (i >= a.a_ngroups) {
  865.                         printf("???  ") ;
  866.                         break ;
  867.                   } else if (a.a_group[i].a_ngnum == gnum) {
  868.                         printf("%-5d", a.a_group[i].a_artno) ;
  869.                         break ;
  870.                   }
  871.             }
  872.             printf("%-22.22s %-30.30s %.20s\n",
  873.                    a.a_ident, a.a_title, a.a_from) ;
  874.       }
  875. }
  876.  
  877.  
  878.  
  879.  
  880. xerror(msg, a1, a2, a3, a4)
  881.       char *msg ;
  882.       {
  883.       putchar('\n') ;
  884.       printf(msg, a1, a2, a3, a4) ;
  885.       putchar('\n') ;
  886.       longjmp(jmp->jbuf, 1) ;
  887. }
  888. !E!O!F!
  889.  
  890. cat > artfile/dumprec.c <<\!E!O!F!
  891. #include <stdio.h>
  892. #include "af.h"
  893. #include <setjmp.h>
  894.  
  895. struct jump {
  896.       jmp_buf jbuf ;
  897.       struct jump *nextj ;
  898. } *jmp ;
  899.  
  900.  
  901.  
  902. main(argc, argv)
  903.       char **argv ;
  904.       {
  905.       char **ap = argv + 1 ;
  906.       char *msgid ;
  907.       struct artrec a ;
  908.       DPTR dp ;
  909.       char artfile[64] ;
  910.       struct jump j ;
  911.       extern int LIB[] ;
  912.       long atol() ;
  913.  
  914.       jmp = &j ;
  915.       if (setjmp(j.jbuf)) {
  916.             exit(2) ;
  917.       }
  918.       if (argc < 2)
  919.             xerror("Usage: dumprec -fartfile message-id...") ;
  920.       pathinit() ;
  921.       sprintf(artfile, "%s/artfile", LIB) ;
  922.       if (strncmp(*ap, "-f", 2) == 0) {
  923.             if (ap[0][2])     strcpy(artfile, *ap + 2) ;
  924.             else              strcpy(artfile, *++ap) ;
  925.             ap++ ;
  926.       }
  927.       genafopen(artfile, "r") ;
  928.       setjmp(j.jbuf) ;
  929.       while ((msgid = *ap++) != NULL) {
  930.             if (msgid[0] >= '0' && msgid[0] <= '9')
  931.                   readrec(dp = atol(msgid), &a) ;
  932.             else if ((dp = lookart(msgid, &a)) == DNULL) {
  933.                   printf("\nNo entry for %s\n", msgid) ;
  934.                   continue ;
  935.             }
  936.             prtentry(&a, dp, msgid) ;
  937.       }
  938.       exit(0) ;
  939. }
  940.  
  941.  
  942.  
  943. prtentry(a, dp, msgid)
  944.       register struct artrec *a ;
  945.       DPTR dp ;
  946.       char *msgid ;
  947.       {
  948.       char *ctime() ;
  949.  
  950.       printf("\nArticle: %ld %s\n", dp, a->a_ident) ;
  951.       if ((a->a_flags & A_DUMMY) == 0) {
  952.             printf("Subject: %s\n", a->a_title) ;
  953.             printf("From: %s\n", a->a_from) ;
  954.             printf("File: %s\n", a->a_file) ;
  955.       }
  956.       printf("Posted: %s", ctime(&a->a_subtime)) ;
  957.       printf("Received: %s", ctime(&a->a_rectime)) ;
  958.       if (a->a_exptime)
  959.             printf("Expires: %s", ctime(&a->a_exptime)) ;
  960.       printf("Lines: %d\n", a->a_nlines) ;
  961.       printf("Flags: %05o\n", a->a_flags) ;
  962.       prtgroups(a) ;
  963.       prtptr("Parent: ", a->a_parent) ;
  964.       prtchildren(a->a_children) ;
  965.       prtptr("Childchain: ", a->a_childchain) ;
  966.       prtptr("Idchain: ", a->a_idchain) ;
  967.       prtptr("Titlechain: ", a->a_titlechain) ;
  968. }
  969.  
  970.  
  971. prtchildren(dp)
  972.       DPTR dp ;
  973.       {
  974.       struct artrec a ;
  975.       char *msg ;
  976.  
  977.       msg = "Children: ";
  978.       while (dp != DNULL) {
  979.             prtptr(msg, dp) ;
  980.             readrec(dp, &a) ;
  981.             dp = a.a_childchain ;
  982.             msg = "\t  " ;
  983.       }
  984. }
  985.  
  986.  
  987. prtgroups(a)
  988.       struct artrec *a ;
  989.       {
  990.       register int i ;
  991.       char *msg = "Newsgroups: ";
  992.  
  993.       for (i = 0 ; i < a->a_ngroups ; i++) {
  994.             printf("%s%d/%d", msg, a->a_group[i].a_ngnum, a->a_group[i].a_artno);
  995.             prtptr(" ", a->a_group[i].a_ngchain) ;
  996.             msg = "\t    ";
  997.       }
  998. }
  999.  
  1000.  
  1001. prtptr(msg, dp)
  1002.       char *msg ;
  1003.       DPTR dp ;
  1004.       {
  1005.       struct artrec a ;
  1006.  
  1007.       printf("%s", msg) ;
  1008.       if (dp == DNULL)
  1009.             printf("null") ;
  1010.       else {
  1011.             printf("%ld ", dp) ;
  1012.             readrec(dp, &a) ;
  1013.             printf("%s", a.a_ident) ;
  1014.       }
  1015.       putchar('\n') ;
  1016. }
  1017.  
  1018.  
  1019.  
  1020. xerror(msg, a1, a2, a3, a4)
  1021.       char *msg ;
  1022.       {
  1023.       putchar('\n') ;
  1024.       printf(msg, a1, a2, a3, a4) ;
  1025.       putchar('\n') ;
  1026.       longjmp(jmp->jbuf, 1) ;
  1027. }
  1028. !E!O!F!
  1029.  
  1030. cat > artfile/dumptree.c <<\!E!O!F!
  1031. #include <stdio.h>
  1032. #include "artfile.h"
  1033. #include "libextern.h"
  1034.  
  1035. char *savestr();
  1036.  
  1037. char *seen[2000];
  1038. char **seenp = seen;
  1039.  
  1040.  
  1041.  
  1042. main(argc, argv)
  1043.       char **argv;
  1044.       {
  1045.       char artfile[64] ;
  1046.       struct artrec a;
  1047.       DPTR dp;
  1048.       int i;
  1049.       int rootflg = 0;
  1050.       struct article *ap;
  1051.       char *msgid;
  1052.       struct article *rootid;
  1053.       char *title;
  1054.       extern int optind;
  1055.       extern char *optarg;
  1056.  
  1057.       pathinit();
  1058.       sprintf(artfile, "%s/artfile", LIB) ;
  1059.       while ((i = getopt(argc, argv, "f:r")) != EOF) {
  1060.             switch (i) {
  1061.             case 'f':
  1062.                   strcpy(artfile, optarg);
  1063.                   break;
  1064.             case 'r':
  1065.                   rootflg++;
  1066.                   break;
  1067.             }
  1068.       }
  1069.       if (optind >= argc)
  1070.             xerror("Usage: prttree message-id\n");
  1071.       msgid = argv[optind];
  1072.       genafopen(artfile, "r") ;
  1073.       if ((dp = lookart(msgid, &a)) == DNULL)
  1074.             xerror("No entry for %s", msgid);
  1075.       rootid = msgid;
  1076.       if ((a.a_flags & A_DUMMY) == 0)
  1077.             title = savestr(a.a_title);
  1078.       else
  1079.             title = "";
  1080.       if (rootflg) {
  1081.             seenp = seen;
  1082.             while (dp != DNULL) {
  1083.                   readrec(dp, &a);
  1084.                   rootid = savestr(a.a_ident);
  1085.                   if (lookid(rootid)) {
  1086.                         printf("loop discovered while searching for parent:\n");
  1087.                         printf("    %ld %s\n", dp, rootid);
  1088.                         do {
  1089.                               readrec(dp = a.a_parent, &a);
  1090.                               printf("    %ld %s\n", dp, a.a_ident);
  1091.                         } while (strcmp(rootid, a.a_ident) != 0);
  1092.                         break;
  1093.                   }
  1094.                   *seenp++ = rootid;
  1095.                   dp = a.a_parent;
  1096.             }
  1097.       }
  1098.       if ((dp = lookart(rootid, &a)) == DNULL)
  1099.             xerror("rootid");
  1100.       if ((a.a_flags & A_DUMMY) == 0)
  1101.             title = a.a_title;
  1102.       seenp = seen;
  1103.       printf("Discussion tree for %s\n", title);
  1104.       prttree(dp, &a, 0, DNULL);
  1105.       exit(0);
  1106. }
  1107.  
  1108.  
  1109. prttree(dp, a, indent, parent)
  1110.       DPTR dp;
  1111.       struct artrec *a;
  1112.       int indent;
  1113.       DPTR parent;
  1114.       {
  1115.       int i;
  1116.       char *p;
  1117.       DPTR dp2;
  1118.       struct artrec a2;
  1119.       struct article *ap;
  1120.  
  1121.       i = indent;
  1122.       while (i >= 8) {
  1123.             putchar('\t');
  1124.             i -= 8;
  1125.       }
  1126.       while (i >= 1) {
  1127.             putchar(' ');
  1128.             i--;
  1129.       }
  1130.       indent += 3;
  1131.       printf("%ld %s", dp, a->a_ident);
  1132.       p = savestr(a->a_ident);
  1133.       if (a->a_parent != parent) {
  1134.             printf(" (parent=%ld!)", a->a_parent);
  1135.       }
  1136.  
  1137.       if (lookid(p)) {
  1138.             printf(" (duplicate)\n");
  1139.             return;
  1140.       }
  1141.       *seenp++ = p;
  1142.       putchar('\n');
  1143.       for (dp2 = a->a_children ; dp2 != DNULL ; dp2 = a2.a_childchain) {
  1144.             readrec(dp2, &a2);
  1145.             prttree(dp2, &a2, indent, dp);
  1146.       }
  1147. }
  1148.  
  1149.  
  1150.  
  1151. xerror(fmt, a1, a2, a3, a4)
  1152.       char *fmt;
  1153.       {
  1154.       fprintf(stderr, fmt, a1, a2, a3, a4);
  1155.       putc('\n', stderr);
  1156.       exit(1);
  1157. }
  1158.  
  1159.  
  1160.  
  1161. lookid(id)
  1162.       register char *id;
  1163.       {
  1164.       register char **p;
  1165.  
  1166.       for (p = seen ; p < seenp ; p++)
  1167.             if (**p == *id && strcmp(*p, id) == 0)
  1168.                   return 1;
  1169.       return 0;
  1170. }
  1171. !E!O!F!
  1172.  
  1173. cat > artfile/genmakefile <<\!E!O!F!
  1174. LIB=../lib
  1175. . $LIB/makedefs
  1176. exec > makefile
  1177. cat <<!
  1178. # makefile 6/30/84
  1179.  
  1180. LIB = $LIB
  1181. !
  1182. cat $LIB/makedefs
  1183. cat <<\!
  1184.  
  1185. DEBUG = -O
  1186. CFLAGS = $(DEBUG) -I$(LIB)
  1187. LFLAGS = $(DEBUG)
  1188.  
  1189. AFBUILD = afbuild.o doadd.o addart.o addrec.o makeaf.o ngtab.o title.o $(LIB)/rpathinit.o $(LIB)/rlib.a
  1190.  
  1191. AFINSERT = afinsert.o doadd.o addart.o addrec.o ngtab.o title.o $(LIB)/rpathinit.o $(LIB)/rlib.a
  1192.  
  1193. DUMPREC = dumprec.o $(LIB)/rpathinit.o $(LIB)/rlib.a
  1194.  
  1195. DUMPNG = dumpng.o $(LIB)/rpathinit.o $(LIB)/rlib.a
  1196.  
  1197. DUMPTREE = dumptree.o $(LIB)/rpathinit.o $(LIB)/rlib.a
  1198.  
  1199. all: makefile afbuild afinsert
  1200.  
  1201. makefile: genmakefile
  1202.     genmakefile
  1203.     @echo 'Makefile changes, so restart makefile.'
  1204.     @sh -c 'exit 22'
  1205.  
  1206. install: all
  1207.     /bin/cp afbuild afinsert $(LIBDIR)
  1208.  
  1209. afbuild: $(AFBUILD)
  1210.     $(CC) -o $@ $(LFLAGS) $(AFBUILD)
  1211.  
  1212. afinsert: $(AFINSERT)
  1213.     $(CC) -o $@ $(LFLAGS) $(AFINSERT)
  1214.  
  1215. dumprec: $(DUMPREC)
  1216.     $(CC) -o $@ $(LFLAGS) $(DUMPREC)
  1217.  
  1218. dumpng: $(DUMPNG)
  1219.     $(CC) -o $@ $(LFLAGS) $(DUMPNG)
  1220.  
  1221. dumptree: $(DUMPTREE)
  1222.     $(CC) -o $@ $(LFLAGS) $(DUMPTREE)
  1223.  
  1224. addart.o addrec.o afbuild.o afinsert.o dumpng.o dumprec.o \
  1225. dumpng.o makeaf.o title.o write.o: $(LIB)/artfile.h $(LIB)/af.h $(FRC)
  1226.  
  1227. doadd.o ngtab.o dumprec.o dumpng.o: $(FRC)
  1228.  
  1229.  
  1230. FRC:
  1231. !
  1232. !E!O!F!
  1233. chmod +x artfile/genmakefile
  1234.  
  1235. cat > artfile/ifuncs.c.10.1 <<\!E!O!F!
  1236. /*
  1237.  * ifuncs - functions used by inews.
  1238.  */
  1239.  
  1240. static char *SccsId = "@(#)ifuncs.c    2.21    3/31/83";
  1241.  
  1242. #include "iparams.h"
  1243.  
  1244. static char histline[256];    /* Assumed initially zero (moved here 6/18/84 KSA) */
  1245.  
  1246. /*
  1247.  * Transmit this article to all interested systems.
  1248.  */
  1249.  
  1250. #ifdef u370
  1251. static struct srec srec;
  1252. static struct hbuf h;
  1253. #endif
  1254.  
  1255. broadcast()
  1256. {
  1257.     register char *nptr, *hptr;
  1258.     register FILE *fp;
  1259. #ifndef u370
  1260.     struct srec srec;
  1261.     struct hbuf h;
  1262. #endif
  1263.  
  1264.     /* h is a local copy of the header we can scribble on */
  1265.     fp = xfopen(ARTICLE, "r");
  1266.     if (hread(&h, fp, TRUE) == NULL)
  1267.         xerror("Cannot reread article");
  1268.     fclose(fp);
  1269.     if (h.distribution[0])
  1270.         strcpy(h.nbuf, h.distribution);
  1271.     ngcat(h.nbuf);
  1272.  
  1273.      /* break path into list of systems. */
  1274.     hptr = nptr = h.path;
  1275.     while (*hptr != '\0') {
  1276.         if (index(NETCHRS, *hptr)) {
  1277.             *hptr++ = '\0';
  1278.             nptr = hptr;
  1279.         } else
  1280.             hptr++;
  1281.     }
  1282.     *nptr = '\0';
  1283.  
  1284.     /* loop once per system. */
  1285.     lock();
  1286.     s_openr();
  1287.     while (s_read(&srec)) {
  1288.         if (strncmp(srec.s_name, FULLSYSNAME, SNLN) == 0)
  1289.             continue;
  1290.         hptr = h.path;
  1291.         while (*hptr != '\0') {
  1292.             if (strncmp(srec.s_name, hptr, SNLN) == 0)
  1293.                 goto contin;
  1294.             while (*hptr++ != '\0')
  1295.                 ;
  1296.         }
  1297.         if (ngmatch(h.nbuf, srec.s_nbuf)) {
  1298.             transmit(&srec, xfopen(ARTICLE, "r"), 1);
  1299.         }
  1300.     contin:;
  1301.     }
  1302.     s_close();
  1303.     unlock();
  1304. }
  1305.  
  1306. /*
  1307.  * Transmit file to system.
  1308.  */
  1309. #define PROC 0004
  1310. transmit(sp, ifp, maynotify)
  1311. register struct srec *sp;
  1312. register FILE *ifp;
  1313. int maynotify;
  1314. {
  1315.     register FILE *ofp;
  1316.     register int c;
  1317.     register char *ptr;
  1318.     struct hbuf hh;
  1319.     char TRANS[BUFLEN];
  1320.     char *argv[20];
  1321.     register int pid, fd;
  1322.     extern char firstbufname[];
  1323.  
  1324. /* A:    afmt: the other machine runs an A news, so we xmit in A format */
  1325.     int afmt = (index(sp->s_flags, 'A') != NULL);
  1326. /* B:    use B format (this is the default - don't use this letter elsewise). */
  1327. /* F:    append name to file */
  1328.     int appfile = (index(sp->s_flags, 'F') != NULL);
  1329. /* H:    history: expand %s into the history line (KSA) */
  1330.     int history = (index(sp->s_flags, 'H') != NULL);  /* (6/18/84 KSA) */
  1331. /* L:    local: don't send the article unless it was generated locally */
  1332.     int local = (index(sp->s_flags, 'L') != NULL);
  1333. /* N:    notify: don't send the article, just tell him we have it */
  1334.     int notify = maynotify && (index(sp->s_flags, 'N') != NULL);
  1335. /* S:    noshell: don't fork a shell to execute the xmit command */
  1336.     int noshell = (index(sp->s_flags, 'S') != NULL);
  1337. /* U:    useexist: use the -c option to uux to use the existing copy */
  1338.     int useexist = (index(sp->s_flags, 'U') != NULL);
  1339.  
  1340.     if (local && mode == PROC)
  1341.         return;
  1342. #ifdef DEBUG
  1343.     printf("Transmitting to '%s'\n", sp->s_name);
  1344. #endif
  1345.     if (!appfile && !useexist && !history) {    /* (6/18/84 KSA) */
  1346.         if (hread(&hh, ifp, TRUE) == NULL) {
  1347.             fprintf(stderr, "Bad header, not transmitting\n");
  1348.             log("Bad header, not transmitting %s re %s to %s",
  1349.                 hh.ident, hh.title, sp->s_name);
  1350.             return;
  1351.         }
  1352.         /* Taken out for obscure reasons - see the standard.
  1353.         ngsquash(hh.nbuf, sp->s_nbuf);
  1354.         */
  1355.         if (hh.nbuf[0] == '\0') {
  1356.             printf("Article not subscribed to by %s\n", sp->s_name);
  1357.             return;
  1358.         }
  1359.         sprintf(TRANS, "%s/trXXXXXX", SPOOL);
  1360.     }
  1361.  
  1362.     if (notify) {
  1363.         char oldid[50];
  1364.         sprintf(hh.title, "ihave %s %s", hh.ident, FULLSYSNAME);
  1365.         sprintf(hh.nbuf, "to.%s.ctl", sp->s_name);
  1366.         strcpy(oldid, hh.ident);
  1367.         getident(&hh);
  1368.         log("tell %s about %s, notif. id %s",
  1369.             sp->s_name, oldid, hh.ident);
  1370.     } else
  1371.         log("xmit article %s to %s",
  1372.             hh.ident, sp->s_name);
  1373.  
  1374.     if (appfile) {
  1375.         if (firstbufname[0] == '\0')
  1376.             xerror("No file name to xmit from");
  1377.         ofp = fopen(sp->s_xmit, "a");
  1378.         if (ofp == NULL)
  1379.             xerror("Cannot append to %s", sp->s_xmit);
  1380.         fprintf(ofp, "%s\n", firstbufname);
  1381.         fclose(ofp);
  1382.         return;
  1383.     }
  1384.     else
  1385. #ifdef UXMIT
  1386.     if (useexist) {
  1387.         if (firstbufname[0] == '\0')
  1388.             xerror("No file name to xmit from");
  1389.         if (*sp->s_xmit == '\0')
  1390.             sprintf(bfr, UXMIT, sp->s_name, firstbufname);
  1391.         else
  1392.             sprintf(bfr, sp->s_xmit, firstbufname);
  1393.     } else
  1394. #endif
  1395.     if (history) {        /* (6/18/84 KSA) */
  1396.         if (*sp->s_xmit == '\0')
  1397.             xerror("no xmit command with H flag");
  1398.         sprintf(bfr, sp->s_xmit, histline);
  1399.     } else
  1400.     {
  1401.         ofp = xfopen(mktemp(TRANS), "w");
  1402.         if (afmt)
  1403.             ohwrite(&hh, ofp);
  1404.         else 
  1405.             hwrite(&hh, ofp);
  1406.         if (!notify)
  1407.             while ((c = getc(ifp)) != EOF)
  1408.                 putc(c, ofp);
  1409.         fclose(ifp);
  1410.         fclose(ofp);
  1411.         if (*sp->s_xmit == '\0')
  1412.             sprintf(bfr, DFTXMIT, sp->s_name, TRANS);
  1413.         else
  1414.             sprintf(bfr, "(%s) < %s", sp->s_xmit, TRANS);
  1415.     }
  1416.  
  1417.     /* At this point, the command to be executed is in bfr. */
  1418.     if (noshell) {
  1419.         if (pid = fork())
  1420.             fwait(pid);
  1421.         else {
  1422.             close(0);
  1423.             open(TRANS, 0);
  1424.             ptr = sp->s_xmit;
  1425.             for (pid = 0; pid < 19; pid++) {
  1426.                 while (isspace(*ptr))
  1427.                     *ptr++ = 0;
  1428.                 argv[pid] = ptr;
  1429.                 while (!isspace(*++ptr) && *ptr)
  1430.                     ;
  1431.                 if (!*ptr)
  1432.                     break;
  1433.             }
  1434.             argv[++pid] = 0;
  1435.             execv(sp->s_xmit, argv);
  1436.             xerror("Can't execv\n");
  1437.         }
  1438.     } else
  1439.         system(bfr);
  1440.     if (!appfile && !useexist && !history)    /* 6/18/84 KSA) */
  1441.         unlink(TRANS);
  1442. }
  1443.  
  1444. typedef struct {
  1445.     char *dptr;
  1446.     int dsize;
  1447. } datum;
  1448.  
  1449. /*
  1450.  * Return TRUE if we have seen this file before, else FALSE.
  1451.  */
  1452. history(hp)
  1453. struct hbuf *hp;
  1454. {
  1455.     register FILE *hfp;
  1456.     register char *p;
  1457.     datum lhs, rhs;
  1458.     datum fetch();
  1459.  
  1460. #ifdef DEBUG
  1461.     fprintf(stderr,"history(%s)\n", hp->ident);
  1462. #endif
  1463.     idlock(hp->ident);
  1464. #ifdef DBM
  1465.     dbminit(ARTFILE);
  1466.     lhs.dptr = hp->ident;
  1467.     lhs.dsize = strlen(lhs.dptr) + 1;
  1468.     rhs = fetch(lhs);
  1469.     if (rhs.dptr)
  1470.         return(TRUE);
  1471. #else
  1472.     hfp = xfopen(ARTFILE, "r");
  1473.     while (fgets(bfr, BUFLEN, hfp) != NULL) {
  1474.         p = index(bfr, '\t');
  1475.         if (p == NULL)
  1476.             p = index(bfr, '\n');
  1477.         if (p != NULL)    /* can happen if nulls in file */
  1478.             *p = 0;
  1479.         if (strcmp(bfr, hp->ident)==0 ||
  1480.                 hp->oident[0] && strcmp(bfr, hp->oident)==0) {
  1481.             fclose(hfp);
  1482.             idunlock();
  1483. #ifdef DEBUG
  1484.             fprintf(stderr,"history returns true\n");
  1485. #endif
  1486.             return(TRUE);
  1487.         }
  1488.     }
  1489.     fclose(hfp);
  1490. #endif
  1491.     addhist(hp->ident);
  1492.     addhist("\t");
  1493. #ifdef DEBUG
  1494.     fprintf(stderr,"history returns false\n");
  1495. #endif
  1496.     return(FALSE);
  1497. }
  1498.  
  1499. /* (deleted by KSA) static char histline[256];    /* Assumed initially zero */
  1500.  
  1501. addhist(msg)
  1502. char *msg;
  1503. {
  1504.     strcat(histline, msg);
  1505. }
  1506.  
  1507. savehist()
  1508. {
  1509.     register FILE *hfp;
  1510.     datum lhs, rhs;
  1511.     long fpos;
  1512.     register char *p;
  1513.  
  1514.     hfp = xfopen(ARTFILE, "a");
  1515.     fpos = ftell(hfp);
  1516.     fprintf(hfp, "%s\n", histline);
  1517.     fclose(hfp);
  1518. #ifdef DBM
  1519.     /* We assume that history has already been called, calling dbminit. */
  1520.     p = index(histline, '\t');
  1521.     if (p)
  1522.         *p = 0;
  1523.     lhs.dptr = histline;
  1524.     lhs.dsize = strlen(lhs.dptr) + 1;
  1525.     rhs.dptr = (char *) &fpos;
  1526.     rhs.dsize = sizeof fpos;
  1527.     store(lhs, rhs);
  1528. #endif
  1529.     histline[0] = 0;
  1530.     idunlock();
  1531. }
  1532.  
  1533. /*
  1534.  * Save partial news.
  1535.  */
  1536. newssave(fd, dummy)
  1537. FILE *fd, *dummy;
  1538. {
  1539.     register FILE *tofd, *fromfd;
  1540.     char sfname[BUFLEN];
  1541.     register int c;
  1542.     struct hbuf h;
  1543.     time_t tim;
  1544.  
  1545.     if (fd == NULL)
  1546.         fromfd = xfopen(INFILE, "r");
  1547.     else
  1548.         fromfd = fd;
  1549.     umask(savmask);
  1550.     setgid(gid);
  1551.     setuid(uid);
  1552.  
  1553.     sprintf(sfname, "%s/%s", userhome, PARTIAL);
  1554.     if ((tofd = fopen(sfname, "a")) == NULL)
  1555.         xerror("Cannot save partial news");
  1556.     time(&tim);
  1557.     fprintf(tofd, "----- News saved at %s\n", arpadate(&tim));
  1558.     while ((c = getc(fromfd)) != EOF)
  1559.         putc(c, tofd);
  1560.     fclose(fromfd);
  1561.     fclose(tofd);
  1562.     printf("News saved in %s\n", sfname);
  1563.     xxit(0);
  1564. }
  1565.  
  1566. /*
  1567.  * Handle dates in header.
  1568.  */
  1569.  
  1570. dates(hp)
  1571. struct hbuf *hp;
  1572. {
  1573.     long edt;
  1574.  
  1575.     time(&hp->rectime);
  1576.     nstrip(strcpy(hp->recdate, arpadate(&hp->rectime)));
  1577.     if (*hp->subdate) {
  1578.         if (cgtdate(hp->subdate) < 0) {
  1579.             log("Bad sub date '%s'", hp->subdate);
  1580.             xerror("Cannot parse submittal date");
  1581.         }
  1582.     } else
  1583.         strcpy(hp->subdate, hp->recdate);
  1584.     if (*hp->expdate) {
  1585.         if ((edt = cgtdate(hp->expdate)) < 0)
  1586.             xerror("Cannot parse expiration date");
  1587.         nstrip(strcpy(hp->expdate, arpadate(&edt)));
  1588.     } else {
  1589.         defexp = TRUE;
  1590.         /*
  1591.          * Default is now applied in expire.c
  1592.         hp->exptime = hp->rectime + DFLTEXP;
  1593.         nstrip(strcpy(hp->expdate, arpadate(&hp->exptime)));
  1594.         */
  1595.     }
  1596. }
  1597.  
  1598. /*
  1599.  *    Exit and cleanup.
  1600.  */
  1601. xxit(status)
  1602. int status;
  1603. {
  1604.     unlink(INFILE);
  1605.     unlink(ARTICLE);
  1606.     while (lockcount > 0)
  1607.         unlock();
  1608.     idunlock();
  1609.     exit(status);
  1610. }
  1611.  
  1612. xerror(message, arg1, arg2)
  1613. char *message;
  1614. int arg1, arg2;
  1615. {
  1616.     char buffer[128];
  1617.  
  1618.     fflush(stdout);
  1619.     sprintf(buffer, message, arg1, arg2);
  1620.     fprintf(stderr, "inews: %s.\n", buffer);
  1621.     log(buffer);
  1622.     xxit(1);
  1623. }
  1624.  
  1625. #ifdef    VMS
  1626.  
  1627. #define    SUBLOCK    "/tmp/netnews.lck.1"
  1628.  
  1629. /*
  1630.  * Newsystem locking.
  1631.  * These routines are different for VMS because we can not
  1632.  * effectively simulate links, and VMS supports multiple
  1633.  * version numbers of files
  1634.  */
  1635. lock()
  1636. {
  1637.     register int i;
  1638.     register int fd;
  1639.  
  1640.     if (lockcount++ == 0) {
  1641.         i = DEADTIME;
  1642.         while ((fd = creat(SUBLOCK, 0444)) < 0) {
  1643.             if (--i < 0) {
  1644.                 unlink(SUBLOCK);
  1645.                 log("News system locked up");
  1646.             }
  1647.             if (i < -3)
  1648.                 xerror("Unable to unlock news system");
  1649.             sleep((unsigned)1);
  1650.         }
  1651.         close(fd);
  1652.     }
  1653. }
  1654.  
  1655. unlock()
  1656. {
  1657.     if (--lockcount == 0)
  1658.         unlink(SUBLOCK);
  1659. }
  1660.  
  1661. #else    VMS
  1662.  
  1663. /*
  1664.  * Newsystem locking.
  1665.  */
  1666.  
  1667. lock()
  1668. {
  1669.     register int i;
  1670.  
  1671.     if (lockcount++ == 0) {
  1672.         i = DEADTIME;
  1673.         while (link(SUBFILE, LOCKFILE)) {
  1674.             if (--i < 0)
  1675.                 xerror("News system locked up");
  1676.             sleep((unsigned)1);
  1677.         }
  1678.     }
  1679. }
  1680.  
  1681. unlock()
  1682. {
  1683.     if (--lockcount == 0)
  1684.         unlink(LOCKFILE);
  1685. }
  1686. #endif    VMS
  1687.  
  1688. char lockname[80];
  1689. idlock(str)
  1690. char *str;
  1691. {
  1692.     register int i;
  1693.     char tempname[80];
  1694.     long now;
  1695.     struct stat sbuf;
  1696.     int fd;
  1697.  
  1698. #ifdef    VMS
  1699.     sprintf(lockname, "/tmp/%s.l.1", str);
  1700.     if ((fd = creat(lockname, 0444)) < 0) {
  1701. #else    VMS
  1702.     sprintf(tempname, "/tmp/LTMP.%d", getpid());
  1703.     sprintf(lockname, "/tmp/L%s", str);
  1704. #ifdef FOURTEENMAX
  1705.     lockname[5 /* /tmp/ */ + 14] = '\0';
  1706. #endif
  1707.     close(creat(tempname, 0666));
  1708.     while (link(tempname, lockname)) {
  1709. #endif    VMS
  1710.         time(&now);
  1711.         i = stat(lockname, &sbuf);
  1712.         if (i < 0) {
  1713.             xerror("Directory permission problem in /tmp");
  1714.         }
  1715.         if (sbuf.st_mtime + 10*60 < now) {
  1716.             unlink(lockname);
  1717.             log("Article %s locked up", str);
  1718.             continue;
  1719.         }
  1720.         log("waiting on lock for %s", lockname);
  1721.         sleep((unsigned)60);
  1722.     }
  1723. #ifdef VMS
  1724.     close(fd);
  1725. #else
  1726.     unlink(tempname);
  1727. #endif
  1728.     unlink(tempname);
  1729. }
  1730.  
  1731. idunlock()
  1732. {
  1733.     unlink(lockname);
  1734. }
  1735.  
  1736. /*
  1737.  * Put a unique name into header.ident.
  1738.  */
  1739. getident(hp)
  1740. struct hbuf *hp;
  1741. {
  1742.     long seqn;
  1743.     register FILE *fp;
  1744.  
  1745.     lock();
  1746.     fp = xfopen(SEQFILE, "r");
  1747.     fgets(bfr, BUFLEN, fp);
  1748.     fclose(fp);
  1749.     seqn = atol(bfr) + 1;
  1750. #ifdef    VMS
  1751.     unlink(SEQFILE);
  1752. #endif    VMS
  1753.     fp = xfopen(SEQFILE, "w");
  1754.     fprintf(fp, "%ld\n", seqn);
  1755.     fclose(fp);
  1756.     unlock();
  1757.     sprintf(hp->ident, "<%ld@%s%s>", seqn, FULLSYSNAME, MYDOMAIN);
  1758. }
  1759.  
  1760. /*
  1761.  * Log the given message, with printf strings and parameters allowed,
  1762.  * on the log file, if it can be written.  The date and an attempt at
  1763.  * figuring out the remote system name are also logged.
  1764.  */
  1765. log(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
  1766. char *fmt;
  1767. {
  1768.     FILE *logfile;
  1769.     char msg[256];
  1770.     char *logtime, *p, *q;
  1771.     char rmtsys[256];
  1772.     char c;
  1773.     long t;
  1774.  
  1775.     if (header.relayversion[0]) {
  1776.         for (p=header.relayversion; p; p=index(p+1, 's'))
  1777.             if (strncmp(p, "site ", 5) == 0)
  1778.                 break;
  1779.         if (p == NULL)
  1780.             goto crackpath;
  1781.         p += 4;
  1782.         while (*p == ' ' || *p == '\t')
  1783.             p++;
  1784.         for (q=p; *q && *q!=' ' && *q != '\t'; q++)
  1785.             ;
  1786.         c = *q;
  1787.         strcpy(rmtsys, p);
  1788.         *q = c;
  1789.     } else {
  1790. crackpath:
  1791.         strcpy(rmtsys, header.path);
  1792.         p = index(rmtsys, '!');
  1793.         if (p == NULL)
  1794.             p = index(rmtsys, ':');
  1795.         if (p)
  1796.             *p = 0;
  1797.         else {
  1798.             p = rindex(rmtsys, '@');
  1799.             if (p)
  1800.                 strcpy(rmtsys, p+1);
  1801.             else
  1802.                 strcpy(rmtsys, "local");
  1803.         }
  1804.     }
  1805.  
  1806.     time(&t);
  1807.     logtime = ctime(&t);
  1808.     logtime[16] = 0;
  1809.     logtime += 4;
  1810.  
  1811.     sprintf(msg, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
  1812.  
  1813.     lock();
  1814.     if (access(logfname, 0)) {
  1815.         unlock(0);
  1816.         return;
  1817.     }
  1818.     logfile = fopen(logfname, "a");
  1819.     if (logfile == NULL) {
  1820.         unlock(0);
  1821.         return;
  1822.     }
  1823.     fprintf(logfile, "%s %s\t%s\n", logtime, rmtsys, msg);
  1824.     fclose(logfile);
  1825.     unlock();
  1826. }
  1827.  
  1828. /*
  1829.  * Check if header.nbuf contains only valid newsgroup names;
  1830.  * exit with error if not valid.
  1831.  *
  1832.  * a == TRUE means header.nbuf is subscription list
  1833.  * a == FALSE means header.nbuf is newsgroup list
  1834.  */
  1835.  
  1836. ngfcheck(a)
  1837. int a;
  1838. {
  1839.     char ngcheck[NGFSIZ];    /* Hold NGFILE newsgroups */
  1840.     char tbuf[BUFLEN];    /* hold single header.nbuf news group */
  1841.     register char *s1, *s2;
  1842.     register FILE *f;
  1843.  
  1844.     s1 = ngcheck;
  1845.     f = xfopen(NGFILE, "r");
  1846.     while (fgets(bfr, BUFLEN, f) != NULL) {
  1847.         for (s2 = bfr; *s2 != '\0' &&
  1848.             *s2 != ' ' && *s2 != '\t' &&
  1849.             *s2 != ':' && *s2 != '\n';) {
  1850.             if (s1 >= &ngcheck[NGFSIZ-2])
  1851.                 xerror("NGFILE too long");
  1852.             *s1++ = *s2++;
  1853.         }
  1854.         *s1++ = NGDELIM;
  1855.     }
  1856.     *s1 = '\0';
  1857.     fclose(f);
  1858.     for (s1 = header.nbuf; *s1 != '\0';) {
  1859.         if (*s1 == NEGCHAR)
  1860.             s1++;
  1861.         s2 = tbuf;
  1862.         while ((*s2++ = *s1++) != NGDELIM)
  1863.             if (s1[-1] == ':')
  1864.                 xerror("Newsgroup cannot contain ':'");
  1865.         *s2 = '\0';
  1866.         s2 = tbuf;
  1867.         if (!ngmatch(s2, ngcheck) && (!a || !ngmatch(ngcheck, s2))) {
  1868.             ngdel(s2);
  1869.             sprintf(bfr, "Bad news group \"%s\"", s2);
  1870.             newssave(stdin, NULL);
  1871.             xerror(bfr);
  1872.         }
  1873.     }
  1874. }
  1875.  
  1876. /*
  1877.  * Figure out who posted the article (which is locally entered).
  1878.  * The results are placed in the header structure hp.
  1879.  */
  1880. gensender(hp, logname)
  1881. struct hbuf *hp;
  1882. char *logname;
  1883. {
  1884.     char *fn;
  1885.     static char buf[100];
  1886.     char buf2[100];
  1887.     char *fullname(), *getenv();
  1888.     char *p;
  1889.     int fd;
  1890.  
  1891.     fn = getenv("NAME");
  1892.  
  1893.     if (fn == NULL) {
  1894.         sprintf(buf, "%s/%s", getenv("HOME"), ".name");
  1895.         fd = open(buf, 0);
  1896.         if (fd >= 0) {
  1897.             read(fd, buf2, sizeof buf2);
  1898.             close(fd);
  1899.             if (buf2[0] >= 'A')
  1900.                 fn = buf2;
  1901.             for (p=fn; *p; p++)
  1902.                 if (*p < ' ')
  1903.                     *p = 0;
  1904.         }
  1905.     }
  1906.  
  1907.     if (fn == NULL)
  1908.         fn = fullname(logname);
  1909.  
  1910.     sprintf(hp->path, "%s", logname);
  1911.     sprintf(hp->from, "%s@%s%s (%s)", logname, FULLSYSNAME, MYDOMAIN, fn);
  1912. }
  1913.  
  1914. /*
  1915.  * Trap interrupts.
  1916.  */
  1917. onsig(n)
  1918. int n;
  1919. {
  1920.     static int numsigs = 0;
  1921.     /*
  1922.      * Most UNIX systems reset caught signals to SIG_DFL.
  1923.      * This bad design requires that the trap be set again here.
  1924.      * Unfortunately, if the signal recurs before the trap is set,
  1925.      * the program will die, possibly leaving the lock in place.
  1926.      */
  1927.     if (++numsigs > 100) {
  1928.         log("readnews ran away looping on signal %d", n);
  1929.         xxit(1);
  1930.     }
  1931.     signal(n, onsig);
  1932.     sigtrap = n;
  1933. }
  1934.  
  1935. /*
  1936.  * If the stdin begins with "#", we assume we have been fed a batched
  1937.  * shell script which looks like this:
  1938.  *    #! rnews 1234
  1939.  *    article with 1234 chars
  1940.  *    #! rnews 4321
  1941.  *    article with 4321 chars
  1942.  *
  1943.  * In this case we just exec the unbatcher and let it unpack and call us back.
  1944.  *
  1945.  * Note that there is a potential security hole here.  If the batcher is
  1946.  * /bin/sh, someone could ship you arbitrary stuff to run as shell commands.
  1947.  * The main protection you have is that the effective uid will be news, not
  1948.  * uucp and not the super user.  (That, plus the fact that BATCH is set to
  1949.  * "unbatch" as the system is distributed.)  If you want to run a batched link
  1950.  * and you are security concious, do not use /bin/sh as the unbatcher.
  1951.  * the thing to do is to change BATCH in your localize.sh file from /bin/sh
  1952.  * to some restricted shell which can only run rnews.
  1953.  */
  1954. checkbatch()
  1955. {
  1956.     int c;
  1957.  
  1958. #ifdef BATCH
  1959.     c = getc(stdin);
  1960.     ungetc(c, stdin);
  1961.     clearerr(stdin);
  1962.     if (c == '#') {
  1963.         reset_stdin();
  1964.         execl(BATCH, "news-unpack", 0);
  1965.         xerror("Unable to exec shell to unpack news.\n");
  1966.     }
  1967. #endif
  1968. }
  1969.  
  1970. /*
  1971.  * We've already done a read on stdin, and we want to seek back to the
  1972.  * beginning.  We want the real file descriptor (beyond buffers) to
  1973.  * reflect the true beginning.  Do whatever is necessary.
  1974.  */
  1975. reset_stdin()
  1976. {
  1977.     register FILE *ofd;
  1978.     register int c;
  1979.     char *ofdname;
  1980.  
  1981.     /* First try to seek back - if so, it's a cheap way back. */
  1982.     if (lseek(0, 0L, 0) == 0)
  1983.         return;
  1984.  
  1985.     /* Can't seek, so have to copy input to a file and use that. */
  1986.     ofdname = "/tmp/inewsXXXXX";
  1987.     mktemp(ofdname);
  1988.     ofd = fopen(ofdname, "w");
  1989.     while ((c=getc(stdin)) != EOF)
  1990.         putc(c, ofd);
  1991.     fclose(stdin);
  1992.     fclose(ofd);
  1993.  
  1994.     /* Now for a few lower level hacks to reopen stdin and make
  1995.      * absolutely sure that the right fd's are done for the exec.
  1996.      */
  1997.     close(0);        /* to make sure stdin is really closed. */
  1998.     open(ofdname, 0);    /* returns zero */
  1999.     unlink(ofdname);    /* to avoid cleaning it up later. */
  2000. }
  2001. !E!O!F!
  2002.  
  2003. cat > artfile/makeaf.c <<\!E!O!F!
  2004. #include <stdio.h>
  2005. #include "af.h"
  2006.  
  2007.  
  2008.  
  2009. /*
  2010.  * Create a new artfile.
  2011.  */
  2012.  
  2013. makeaf(name, idtlen, maxng, ttlen)
  2014.       char *name ;
  2015.       {
  2016.       register FILE *fp ;
  2017.       DPTR offset, count ;
  2018.       struct afheader afhd ;
  2019.  
  2020.       if ((fp = fopen(name, "w")) == NULL)
  2021.             xerror("Can't create %s", name) ;
  2022.       offset = count = sizeof afhd ;
  2023.       afhd.af_magic = AF_MAGIC ;
  2024.       afhd.af_version = AF_VERSION ;
  2025.       afhd.af_idtab = offset ;
  2026.       afhd.af_idtlen = idtlen ;
  2027.       offset += idtlen * sizeof (DPTR) ;
  2028.       afhd.af_nglist = offset ;
  2029.       afhd.af_maxng = maxng ;
  2030.       offset += maxng * sizeof (DPTR) ;
  2031.       afhd.af_titletab = offset ;
  2032.       afhd.af_ttlen = ttlen ;
  2033.       offset += ttlen * sizeof (DPTR) ;
  2034.       afhd.af_records = afhd.af_free = offset ;
  2035.       fwrite((char *)&afhd, sizeof afhd, 1, fp) ;
  2036.       while (count < offset) {
  2037.             putc('\0', fp) ;
  2038.             count++ ;
  2039.       }
  2040.       if (ferror(fp) || fclose(fp) == EOF)
  2041.             xerror("Write error in makeaf") ;
  2042. }
  2043. !E!O!F!
  2044.  
  2045. cat > artfile/mkngfile <<\!E!O!F!
  2046. # Construct the groupfile.
  2047. awk '{ print $1 " " NR }' ${1-/usr/lib/news/active} > /tmp/ng$$
  2048. wc -l < /tmp/ng$$
  2049. cat /tmp/ng$$
  2050. !E!O!F!
  2051. chmod +x artfile/mkngfile
  2052.  
  2053. cat > artfile/ngtab.c <<\!E!O!F!
  2054. #include <stdio.h>
  2055. #include "ng.h"
  2056.  
  2057.  
  2058. static char MODGROUPS[] = "all.announce,mod.all,all.mod,fa.all,control,junk" ;
  2059. struct ngrec *ngroup ;
  2060. extern int maxng ;
  2061.  
  2062.  
  2063.  
  2064. /*
  2065.  * Read in the newsgroup file.
  2066.  */
  2067.  
  2068. getngtab() {
  2069.       struct ngrec ng ;
  2070.       char *savestr(), *calloc(), *realloc() ;
  2071.  
  2072.       gfopen() ;
  2073.       if ((ngroup = calloc(sizeof(*ngroup), maxng)) == NULL)
  2074.             xerror("out of space") ;
  2075.       ALL_GROUPS(ng) {
  2076.             ngroup[ng.g_num - 1] = ng ;
  2077.       }
  2078.       gfclose() ;
  2079. }
  2080.  
  2081.  
  2082.  
  2083. /*
  2084.  * Initialize without reading in the newsgroup file.
  2085.  */
  2086.  
  2087. ngtinit() {
  2088.       char *ckmalloc() ;
  2089.  
  2090.       maxng = 0 ;
  2091.       ngroup = ckmalloc(sizeof(struct ngrec)) ;
  2092. }
  2093.  
  2094.  
  2095.  
  2096. /*
  2097.  * Convert a newsgroup number to a newsgroup name
  2098.  */
  2099.  
  2100. char *
  2101. ngname(num) {
  2102.       return ngroup[num - 1].g_name ;
  2103. }
  2104.  
  2105.  
  2106.  
  2107. /*
  2108.  * Convert a newsgroup name to a number
  2109.  */
  2110.  
  2111. int
  2112. ngnum(name)
  2113.       char *name ;
  2114.       {
  2115.       register i ;
  2116.       register struct ngrec *gp ;
  2117.       char n[MAXNGNAME] ;
  2118.  
  2119.       scopyn(name, n, MAXNGNAME) ;
  2120.       for (gp = ngroup, i = maxng ; --i >= 0 ; gp++)
  2121.             if (strcmp(gp->g_name, n) == 0)
  2122.                   return gp - ngroup + 1 ;
  2123.       printf("ngnum: %s not found\n", name) ;        /*DEBUG*/
  2124.       return -1 ;
  2125. }
  2126.  
  2127.  
  2128.  
  2129. newng(name)
  2130.       char *name ;
  2131.       {
  2132.       register int i ;
  2133.  
  2134.       for (i = 0 ; i < maxng ; i++) {
  2135.             if (ngroup[i].g_name[0] == '\0')
  2136.                   break ;
  2137.       }
  2138.       printf("newng %s assigns %d", name, i + 1) ;    /*DEBUG*/
  2139.       if (i == maxng) {
  2140.             if ((ngroup = realloc((char *)ngroup, (i + 1) * sizeof ngroup[0])) == NULL)
  2141.                   xerror("out of space") ;
  2142.             maxng++ ;
  2143.             printf(", maxng upped") ;            /*DEBUG*/
  2144.       }
  2145.       printf("\n") ;                    /*DEBUG*/
  2146.       scopyn(name, ngroup[i].g_name, MAXNGNAME) ;
  2147.       ngroup[i].g_flags = ngmatch(name, MODGROUPS)? G_MOD : 0 ;
  2148.       return ngroup[i].g_num = i + 1 ;
  2149. }
  2150.  
  2151.  
  2152.  
  2153. writengfile() {
  2154.       char newname[64], curname[64], oldname[64] ;
  2155.       FILE *fp ;
  2156.       int i ;
  2157.       register struct ngrec *gp ;
  2158.       extern char LIB[] ;
  2159.  
  2160.       printf("writeng called\n") ;        /*DEBUG*/
  2161.       sprintf(curname, "%s/groupfile", LIB) ;
  2162.       sprintf(newname, "%s.tmp", curname) ;
  2163.       sprintf(oldname, "%s.bak", curname) ;
  2164.       unlink(newname) ;
  2165.       if ((fp = fopen(newname, "w")) == NULL)
  2166.             xerror("Can't create %s", newname) ;
  2167.       fprintf(fp, "%d\n", maxng) ;
  2168.       for (i = maxng, gp = ngroup ; --i >= 0 ; gp++) {
  2169.             fprintf(fp, "%s %d", gp->g_name, gp->g_num) ;
  2170.             if (gp->g_flags & G_MOD)
  2171.                   fputs(" -m", fp) ;
  2172.             fputc('\n', fp) ;
  2173.       }
  2174.       if (ferror(fp) || fclose(fp) == EOF)
  2175.             xerror("Write error on %s", newname) ;
  2176.       rename(curname, oldname) ;
  2177.       if (rename(newname, curname) < 0)
  2178.             xerror("rename %s failed", newname) ;
  2179. }
  2180. !E!O!F!
  2181.  
  2182. cat > artfile/title.c <<\!E!O!F!
  2183. #include <stdio.h>
  2184. #include "af.h"
  2185.  
  2186. #define MAXTITLE 256    /* where does this belong? */
  2187. #define equal(s1, s2)    (strcmp(s1, s2) == 0)
  2188.  
  2189.  
  2190. /*
  2191.  * Return a pointer to the hash chain for this title.
  2192.  */
  2193.  
  2194. DPTR
  2195. htitle(title)
  2196.       register char *title ;
  2197.       {
  2198.       char buf[MAXTITLE] ;
  2199.  
  2200.       while (isre(title))
  2201.             for (title += 3 ; *title == ' ' ; title++) ;
  2202.       strcpy(buf, title) ;
  2203.       rmnf(buf) ;
  2204.       return afhd.af_titletab + hash(buf, afhd.af_ttlen) * sizeof(DPTR) ;
  2205. }
  2206.  
  2207.  
  2208.  
  2209. /*
  2210.  * Determine if a1 is the parent of a2 using titles.
  2211.  */
  2212.  
  2213. tparent(a1, a2)
  2214.       struct artrec *a1, *a2 ;
  2215.       {
  2216.       char t1[MAXTITLE], t2[MAXTITLE] ;
  2217.       char *p ;
  2218.  
  2219.       if (a1->a_subtime > a2->a_subtime || !isre(a2->a_title))
  2220.             return 0 ;
  2221.       strcpy(t1, a1->a_title), strcpy(t2, a2->a_title) ;
  2222.       if (rmnf(t1)) {
  2223.             if (!rmnf(t2))
  2224.                   return 0 ;
  2225.       } else {
  2226.             rmnf(t2) ;
  2227.       }
  2228.       for (p = t2 + 3 ; *p == ' ' ; p++) ;    /* skip over "Re:" */
  2229.       if (!equal(t1, p))
  2230.             return 0 ;
  2231.       return 1 ;
  2232. }
  2233. !E!O!F!
  2234.  
  2235. echo Part 1 of 7 extracted.
  2236.  
  2237.  
  2238.